#include "../mqsever/mq_message.hpp"
#include <gtest/gtest.h>
mymq::MessageManager::ptr mmp;

class MessageTest : public testing::Environment
{
    // Override this to define how to set up the environment.
    virtual void SetUp()
    {
        std::cout << "单元测试前的初始化" << std::endl;
        mmp = std::make_shared<mymq::MessageManager>("./data/message");
        mmp->initQueueMessage("queue1");
    }

    // Override this to define how to tear down the environment.
    virtual void TearDown()
    {
        //mmp->clear();
        std::cout << "单元测试结束后的清理" << std::endl;
    }
};

// 新增消息测试：新增消息，然后观察可获取消息数量，以及持久化消息数量
TEST(message_test, insert_test)
{
    mymq::BasicProperties properties;
    properties.set_id(mymq::UUIDHelper::uuid());
    properties.set_delivery_mode(mymq::DeliverMode::DURABLE);
    properties.set_routing_key("news.music.pop");

    mmp->insert("queue1", &properties, "hello world1", mymq::DeliverMode::DURABLE);
    mmp->insert("queue1", nullptr, "hello world2", mymq::DeliverMode::DURABLE);
    mmp->insert("queue1", nullptr, "hello world3", mymq::DeliverMode::DURABLE);
    mmp->insert("queue1", nullptr, "hello world4", mymq::DeliverMode::DURABLE);
    mmp->insert("queue1", nullptr, "hello world5", mymq::DeliverMode::UNDURABLE);

    ASSERT_EQ(mmp->getable_count("queue1"), 5);
    ASSERT_EQ(mmp->total_count("queue1"), 4);
    ASSERT_EQ(mmp->waitack_count("queue1"), 0);
    ASSERT_EQ(mmp->durable_count("queue1"), 4);
}



// // 获取消息测试：获取一条消息，然后在不进行确认的情况下，查看可获取消息数量，待确认消息数量，以及测试消息获取的顺序
// TEST(message_test, select_test)
// {
//     ASSERT_EQ(mmp->getable_count("queue1"),5);

//     mymq::MessagePtr msg1 = mmp->front("queue1");
//     ASSERT_NE(msg1.get(),nullptr);
//     ASSERT_EQ(msg1->paylode().body(), std::string("hello world1"));
//     ASSERT_EQ(mmp->getable_count("queue1"),4);
//     ASSERT_EQ(mmp->waitack_count("queue1"),1);

//     mymq::MessagePtr msg2 = mmp->front("queue1");
//     ASSERT_NE(msg2.get(),nullptr);
//     ASSERT_EQ(msg2->paylode().body(), std::string("hello world2"));
//     ASSERT_EQ(mmp->getable_count("queue1"),3);
//     ASSERT_EQ(mmp->waitack_count("queue1"),2);

//     mymq::MessagePtr msg3 = mmp->front("queue1");
//     ASSERT_NE(msg3.get(),nullptr);
//     ASSERT_EQ(msg3->paylode().body(), std::string("hello world3"));
//     ASSERT_EQ(mmp->getable_count("queue1"),2);
//     ASSERT_EQ(mmp->waitack_count("queue1"),3);

//     mymq::MessagePtr msg4 = mmp->front("queue1");
//     ASSERT_NE(msg4.get(),nullptr);
//     ASSERT_EQ(msg4->paylode().body(), std::string("hello world4"));
//     ASSERT_EQ(mmp->getable_count("queue1"),1);
//     ASSERT_EQ(mmp->waitack_count("queue1"),4);

//     mymq::MessagePtr msg5 = mmp->front("queue1");
//     ASSERT_NE(msg5.get(), nullptr);
//     ASSERT_EQ(msg5->paylode().body(), std::string("hello world5"));
//     ASSERT_EQ(mmp->getable_count("queue1"),0);
//     ASSERT_EQ(mmp->waitack_count("queue1"),5);
// }
// 删除消息测试：确认一条消息，查看持久化消息数量，待确认消息数量
TEST(message_test, delete_test)
{
    ASSERT_EQ(mmp->getable_count("queue1"), 5);

    mymq::MessagePtr msg1 = mmp->front("queue1");
    ASSERT_NE(msg1.get(), nullptr);
    ASSERT_EQ(msg1->paylode().body(), std::string("hello world1"));
    ASSERT_EQ(mmp->getable_count("queue1"), 4);
    ASSERT_EQ(mmp->waitack_count("queue1"), 1);

    mmp->ack("queue1",msg1->paylode().properties().id());
    ASSERT_EQ(mmp->waitack_count("queue1"), 0);
    ASSERT_EQ(mmp->durable_count("queue1"), 3);
    ASSERT_EQ(mmp->total_count("queue1"), 4);



}
// 销毁测试
TEST(message_test, clear_test)     
{
    mmp->destoryQueueMessage("queue1");
}

// //恢复历史消息测试
// mymq::MessageManager::ptr mmp1;

// class MessageTest2 : public testing::Environment
// {
//     // Override this to define how to set up the environment.
//     virtual void SetUp()
//     {
//         std::cout << "单元测试前的初始化" << std::endl;
//         mmp1 = std::make_shared<mymq::MessageManager>("./data/message");
//     }

//     // Override this to define how to tear down the environment.
//     virtual void TearDown()
//     {
//         // mmp1->clear();
//         std::cout << "单元测试结束后的清理" << std::endl;
//     }
// };

// TEST(message_test2, recovery_test)
// {
//     mmp1->initQueueMessage("queue1");

//     ASSERT_EQ(mmp1->getable_count("queue1"), 3);

//     // mymq::MessagePtr msg1 = mmp1->front("queue1");
//     // ASSERT_NE(msg1.get(), nullptr);
//     // ASSERT_EQ(msg1->paylode().body(), std::string("hello world1"));
//     // ASSERT_EQ(mmp1->getable_count("queue1"), 3);
//     // ASSERT_EQ(mmp1->waitack_count("queue1"), 1);

//     // mymq::MessagePtr msg2 = mmp1->front("queue1");
//     // ASSERT_NE(msg2.get(), nullptr);
//     // ASSERT_EQ(msg2->paylode().body(), std::string("hello world2"));
//     // ASSERT_EQ(mmp1->getable_count("queue1"), 2);
//     // ASSERT_EQ(mmp1->waitack_count("queue1"), 2);

//     // mymq::MessagePtr msg3 = mmp1->front("queue1");
//     // ASSERT_NE(msg3.get(), nullptr);
//     // ASSERT_EQ(msg3->paylode().body(), std::string("hello world3"));
//     // ASSERT_EQ(mmp1->getable_count("queue1"), 1);
//     // ASSERT_EQ(mmp1->waitack_count("queue1"), 3);

//     // mymq::MessagePtr msg4 = mmp1->front("queue1");
//     // ASSERT_NE(msg4.get(), nullptr);
//     // ASSERT_EQ(msg4->paylode().body(), std::string("hello world4"));
//     // ASSERT_EQ(mmp1->getable_count("queue1"), 0);
//     // ASSERT_EQ(mmp1->waitack_count("queue1"), 4);
// }
int main(int argc, char *argv[])
{
    testing::InitGoogleTest(&argc, argv);
    testing::AddGlobalTestEnvironment(new MessageTest);
    //testing::AddGlobalTestEnvironment(new MessageTest2);

    int ret = RUN_ALL_TESTS();
    return 0;
}